home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / lib / gcc-lib / ppc-amigaos / 2.95.1 / sys-include / powerup / ppcpragmas / cardres_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-03-13  |  10KB  |  339 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_CARDRES_H
  4. #define _PPCPRAGMA_CARDRES_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__CARDRES_H
  7. #include <powerup/ppcinline/cardres.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef CARDRES_BASE_NAME
  24. #define CARDRES_BASE_NAME CardResource
  25. #endif /* !CARDRES_BASE_NAME */
  26.  
  27. #define    BeginCardAccess(handle)    _BeginCardAccess(CARDRES_BASE_NAME, handle)
  28.  
  29. static __inline BOOL
  30. _BeginCardAccess(void *CardResource, struct CardHandle *handle)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a1        =(ULONG) handle;
  40.     MyCaos.caos_Un.Offset    =    (-24);
  41.     MyCaos.a6        =(ULONG) CardResource;    
  42.     return((BOOL)PPCCallOS(&MyCaos));
  43. }
  44.  
  45. #define    CardAccessSpeed(handle, nanoseconds)    _CardAccessSpeed(CARDRES_BASE_NAME, handle, nanoseconds)
  46.  
  47. static __inline ULONG
  48. _CardAccessSpeed(void *CardResource, struct CardHandle *handle, unsigned long nanoseconds)
  49. {
  50. struct Caos    MyCaos;
  51.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  52. //    MyCaos.M68kStart    =    NULL;
  53. //    MyCaos.M68kSize        =    0;
  54.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  55. //    MyCaos.PPCStart        =    NULL;
  56. //    MyCaos.PPCSize        =    0;
  57.     MyCaos.a1        =(ULONG) handle;
  58.     MyCaos.d0        =(ULONG) nanoseconds;
  59.     MyCaos.caos_Un.Offset    =    (-54);
  60.     MyCaos.a6        =(ULONG) CardResource;    
  61.     return((ULONG)PPCCallOS(&MyCaos));
  62. }
  63.  
  64. #define    CardChangeCount()    _CardChangeCount(CARDRES_BASE_NAME)
  65.  
  66. static __inline ULONG
  67. _CardChangeCount(void *CardResource)
  68. {
  69. struct Caos    MyCaos;
  70.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  71. //    MyCaos.M68kStart    =    NULL;
  72. //    MyCaos.M68kSize        =    0;
  73.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  74. //    MyCaos.PPCStart        =    NULL;
  75. //    MyCaos.PPCSize        =    0;
  76.     MyCaos.caos_Un.Offset    =    (-96);
  77.     MyCaos.a6        =(ULONG) CardResource;    
  78.     return((ULONG)PPCCallOS(&MyCaos));
  79. }
  80.  
  81. #define    CardForceChange()    _CardForceChange(CARDRES_BASE_NAME)
  82.  
  83. static __inline BOOL
  84. _CardForceChange(void *CardResource)
  85. {
  86. struct Caos    MyCaos;
  87.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  88. //    MyCaos.M68kStart    =    NULL;
  89. //    MyCaos.M68kSize        =    0;
  90.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  91. //    MyCaos.PPCStart        =    NULL;
  92. //    MyCaos.PPCSize        =    0;
  93.     MyCaos.caos_Un.Offset    =    (-90);
  94.     MyCaos.a6        =(ULONG) CardResource;    
  95.     return((BOOL)PPCCallOS(&MyCaos));
  96. }
  97.  
  98. #define    CardInterface()    _CardInterface(CARDRES_BASE_NAME)
  99.  
  100. static __inline ULONG
  101. _CardInterface(void *CardResource)
  102. {
  103. struct Caos    MyCaos;
  104.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  105. //    MyCaos.M68kStart    =    NULL;
  106. //    MyCaos.M68kSize        =    0;
  107.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  108. //    MyCaos.PPCStart        =    NULL;
  109. //    MyCaos.PPCSize        =    0;
  110.     MyCaos.caos_Un.Offset    =    (-102);
  111.     MyCaos.a6        =(ULONG) CardResource;    
  112.     return((ULONG)PPCCallOS(&MyCaos));
  113. }
  114.  
  115. #define    CardMiscControl(handle, control_bits)    _CardMiscControl(CARDRES_BASE_NAME, handle, control_bits)
  116.  
  117. static __inline UBYTE
  118. _CardMiscControl(void *CardResource, struct CardHandle *handle, unsigned long control_bits)
  119. {
  120. struct Caos    MyCaos;
  121.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  122. //    MyCaos.M68kStart    =    NULL;
  123. //    MyCaos.M68kSize        =    0;
  124.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  125. //    MyCaos.PPCStart        =    NULL;
  126. //    MyCaos.PPCSize        =    0;
  127.     MyCaos.a1        =(ULONG) handle;
  128.     MyCaos.d1        =(ULONG) control_bits;
  129.     MyCaos.caos_Un.Offset    =    (-48);
  130.     MyCaos.a6        =(ULONG) CardResource;    
  131.     return((UBYTE)PPCCallOS(&MyCaos));
  132. }
  133.  
  134. #define    CardProgramVoltage(handle, voltage)    _CardProgramVoltage(CARDRES_BASE_NAME, handle, voltage)
  135.  
  136. static __inline LONG
  137. _CardProgramVoltage(void *CardResource, struct CardHandle *handle, unsigned long voltage)
  138. {
  139. struct Caos    MyCaos;
  140.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  141. //    MyCaos.M68kStart    =    NULL;
  142. //    MyCaos.M68kSize        =    0;
  143.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  144. //    MyCaos.PPCStart        =    NULL;
  145. //    MyCaos.PPCSize        =    0;
  146.     MyCaos.a1        =(ULONG) handle;
  147.     MyCaos.d0        =(ULONG) voltage;
  148.     MyCaos.caos_Un.Offset    =    (-60);
  149.     MyCaos.a6        =(ULONG) CardResource;    
  150.     return((LONG)PPCCallOS(&MyCaos));
  151. }
  152.  
  153. #define    CardResetCard(handle)    _CardResetCard(CARDRES_BASE_NAME, handle)
  154.  
  155. static __inline BOOL
  156. _CardResetCard(void *CardResource, struct CardHandle *handle)
  157. {
  158. struct Caos    MyCaos;
  159.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  160. //    MyCaos.M68kStart    =    NULL;
  161. //    MyCaos.M68kSize        =    0;
  162.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  163. //    MyCaos.PPCStart        =    NULL;
  164. //    MyCaos.PPCSize        =    0;
  165.     MyCaos.a1        =(ULONG) handle;
  166.     MyCaos.caos_Un.Offset    =    (-66);
  167.     MyCaos.a6        =(ULONG) CardResource;    
  168.     return((BOOL)PPCCallOS(&MyCaos));
  169. }
  170.  
  171. #define    CardResetRemove(handle, flag)    _CardResetRemove(CARDRES_BASE_NAME, handle, flag)
  172.  
  173. static __inline BOOL
  174. _CardResetRemove(void *CardResource, struct CardHandle *handle, unsigned long flag)
  175. {
  176. struct Caos    MyCaos;
  177.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  178. //    MyCaos.M68kStart    =    NULL;
  179. //    MyCaos.M68kSize        =    0;
  180.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  181. //    MyCaos.PPCStart        =    NULL;
  182. //    MyCaos.PPCSize        =    0;
  183.     MyCaos.a1        =(ULONG) handle;
  184.     MyCaos.d0        =(ULONG) flag;
  185.     MyCaos.caos_Un.Offset    =    (-42);
  186.     MyCaos.a6        =(ULONG) CardResource;    
  187.     return((BOOL)PPCCallOS(&MyCaos));
  188. }
  189.  
  190. #define    CopyTuple(handle, buffer, tuplecode, size)    _CopyTuple(CARDRES_BASE_NAME, handle, buffer, tuplecode, size)
  191.  
  192. static __inline BOOL
  193. _CopyTuple(void *CardResource, struct CardHandle *handle, UBYTE *buffer, unsigned long tuplecode, unsigned long size)
  194. {
  195. struct Caos    MyCaos;
  196.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  197. //    MyCaos.M68kStart    =    NULL;
  198. //    MyCaos.M68kSize        =    0;
  199.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  200. //    MyCaos.PPCStart        =    NULL;
  201. //    MyCaos.PPCSize        =    0;
  202.     MyCaos.a1        =(ULONG) handle;
  203.     MyCaos.a0        =(ULONG) buffer;
  204.     MyCaos.d1        =(ULONG) tuplecode;
  205.     MyCaos.d0        =(ULONG) size;
  206.     MyCaos.caos_Un.Offset    =    (-72);
  207.     MyCaos.a6        =(ULONG) CardResource;    
  208.     return((BOOL)PPCCallOS(&MyCaos));
  209. }
  210.  
  211. #define    DeviceTuple(tuple_data, storage)    _DeviceTuple(CARDRES_BASE_NAME, tuple_data, storage)
  212.  
  213. static __inline ULONG
  214. _DeviceTuple(void *CardResource, UBYTE *tuple_data, struct DeviceTData *storage)
  215. {
  216. struct Caos    MyCaos;
  217.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  218. //    MyCaos.M68kStart    =    NULL;
  219. //    MyCaos.M68kSize        =    0;
  220.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  221. //    MyCaos.PPCStart        =    NULL;
  222. //    MyCaos.PPCSize        =    0;
  223.     MyCaos.a0        =(ULONG) tuple_data;
  224.     MyCaos.a1        =(ULONG) storage;
  225.     MyCaos.caos_Un.Offset    =    (-78);
  226.     MyCaos.a6        =(ULONG) CardResource;    
  227.     return((ULONG)PPCCallOS(&MyCaos));
  228. }
  229.  
  230. #define    EndCardAccess(handle)    _EndCardAccess(CARDRES_BASE_NAME, handle)
  231.  
  232. static __inline BOOL
  233. _EndCardAccess(void *CardResource, struct CardHandle *handle)
  234. {
  235. struct Caos    MyCaos;
  236.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  237. //    MyCaos.M68kStart    =    NULL;
  238. //    MyCaos.M68kSize        =    0;
  239.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  240. //    MyCaos.PPCStart        =    NULL;
  241. //    MyCaos.PPCSize        =    0;
  242.     MyCaos.a1        =(ULONG) handle;
  243.     MyCaos.caos_Un.Offset    =    (-30);
  244.     MyCaos.a6        =(ULONG) CardResource;    
  245.     return((BOOL)PPCCallOS(&MyCaos));
  246. }
  247.  
  248. #define    GetCardMap()    _GetCardMap(CARDRES_BASE_NAME)
  249.  
  250. static __inline struct CardMemoryMap *
  251. _GetCardMap(void *CardResource)
  252. {
  253. struct Caos    MyCaos;
  254.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  255. //    MyCaos.M68kStart    =    NULL;
  256. //    MyCaos.M68kSize        =    0;
  257.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  258. //    MyCaos.PPCStart        =    NULL;
  259. //    MyCaos.PPCSize        =    0;
  260.     MyCaos.caos_Un.Offset    =    (-18);
  261.     MyCaos.a6        =(ULONG) CardResource;    
  262.     return((struct CardMemoryMap *)PPCCallOS(&MyCaos));
  263. }
  264.  
  265. #define    IfAmigaXIP(handle)    _IfAmigaXIP(CARDRES_BASE_NAME, handle)
  266.  
  267. static __inline struct Resident *
  268. _IfAmigaXIP(void *CardResource, struct CardHandle *handle)
  269. {
  270. struct Caos    MyCaos;
  271.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  272. //    MyCaos.M68kStart    =    NULL;
  273. //    MyCaos.M68kSize        =    0;
  274.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  275. //    MyCaos.PPCStart        =    NULL;
  276. //    MyCaos.PPCSize        =    0;
  277.     MyCaos.a2        =(ULONG) handle;
  278.     MyCaos.caos_Un.Offset    =    (-84);
  279.     MyCaos.a6        =(ULONG) CardResource;    
  280.     return((struct Resident *)PPCCallOS(&MyCaos));
  281. }
  282.  
  283. #define    OwnCard(handle)    _OwnCard(CARDRES_BASE_NAME, handle)
  284.  
  285. static __inline struct CardHandle *
  286. _OwnCard(void *CardResource, struct CardHandle *handle)
  287. {
  288. struct Caos    MyCaos;
  289.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  290. //    MyCaos.M68kStart    =    NULL;
  291. //    MyCaos.M68kSize        =    0;
  292.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  293. //    MyCaos.PPCStart        =    NULL;
  294. //    MyCaos.PPCSize        =    0;
  295.     MyCaos.a1        =(ULONG) handle;
  296.     MyCaos.caos_Un.Offset    =    (-6);
  297.     MyCaos.a6        =(ULONG) CardResource;    
  298.     return((struct CardHandle *)PPCCallOS(&MyCaos));
  299. }
  300.  
  301. #define    ReadCardStatus()    _ReadCardStatus(CARDRES_BASE_NAME)
  302.  
  303. static __inline UBYTE
  304. _ReadCardStatus(void *CardResource)
  305. {
  306. struct Caos    MyCaos;
  307.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  308. //    MyCaos.M68kStart    =    NULL;
  309. //    MyCaos.M68kSize        =    0;
  310.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  311. //    MyCaos.PPCStart        =    NULL;
  312. //    MyCaos.PPCSize        =    0;
  313.     MyCaos.caos_Un.Offset    =    (-36);
  314.     MyCaos.a6        =(ULONG) CardResource;    
  315.     return((UBYTE)PPCCallOS(&MyCaos));
  316. }
  317.  
  318. #define    ReleaseCard(handle, flags)    _ReleaseCard(CARDRES_BASE_NAME, handle, flags)
  319.  
  320. static __inline void
  321. _ReleaseCard(void *CardResource, struct CardHandle *handle, unsigned long flags)
  322. {
  323. struct Caos    MyCaos;
  324.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  325. //    MyCaos.M68kStart    =    NULL;
  326. //    MyCaos.M68kSize        =    0;
  327.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  328. //    MyCaos.PPCStart        =    NULL;
  329. //    MyCaos.PPCSize        =    0;
  330.     MyCaos.a1        =(ULONG) handle;
  331.     MyCaos.d0        =(ULONG) flags;
  332.     MyCaos.caos_Un.Offset    =    (-12);
  333.     MyCaos.a6        =(ULONG) CardResource;    
  334.     PPCCallOS(&MyCaos);
  335. }
  336.  
  337. #endif /* SASC Pragmas */
  338. #endif /* !_PPCPRAGMA_CARDRES_H */
  339.